home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-01 / 48asmdbg.zip / SIM1.H < prev   
C/C++ Source or Header  |  1992-04-09  |  18KB  |  717 lines
  1.  
  2. #include <stdio>
  3. #include <string.h>
  4. #include <stdlib>
  5.  
  6. #define STRTYP 0x02a2c
  7. #define REATYP 0x02933
  8. #define IMCTYP 0x02c96
  9. #define ALGTYP 0x02ab8
  10. #define PRGTYP 0x02d9d
  11. #define NAMTYP 0x02e48
  12. #define LOCTYP 0x02e67
  13. #define BINTYP 0x02a4e
  14.  
  15.  
  16. #define d0_init  0x000e9e52 /* any number, hopefully not required */
  17. #define d1_init  0x000e9e54 /* top of display_stack */
  18. #define st_init  0x00000000
  19. #define b_init   0x76768576
  20. #define d_init   0x29004976
  21.  
  22. /*now define contents of "known" locations (ie @d0, @d1...) */
  23. #define RPL      0x000e9e53      /* address of next RPL ins */
  24. #define ST0      (d1_init+0x100) /* pointer to stack level 0 */
  25. #define ST1      (ST0 + 0x100)
  26. #define ST2      (ST1 + 0x100)
  27. #define ST3      (ST2 + 0x100)
  28. #define ST4      (ST3 + 0x100)
  29.  
  30. /* now a few aliases */
  31. #define mask_pa mask_p10
  32. #define mask_pb mask_p11
  33. #define mask_pc mask_p12
  34. #define mask_pd mask_p13
  35. #define mask_pe mask_p14
  36. #define mask_pf mask_p15
  37.  
  38. typedef unsigned long reg_t[2];
  39.  
  40. reg_t tmp;
  41. reg_t a,b={0,b_init},c,d={0,d_init};
  42. reg_t r0,r1,r2,r3,r4;
  43. reg_t d0={0,d0_init},d1={0,d1_init},pc={0,0},st={0,st_init},p={0,0};
  44. unsigned char  carry=0,stkptr=6,return_flag;
  45. unsigned long  stack[7]={0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  46. 0xfffff
  47. fff, 0xffffffff, 0xffffffff};
  48.  
  49. /* -------------------------------------------------------------------------
  50.  
  51. /*                      Screen functions for vt100                           */
  52.  
  53. cls() /* clear screen */
  54. {
  55.   printf("%c[2J",27);
  56. }
  57.  
  58. ebl() /* erase bottom line */
  59. {
  60.   bos();
  61.   printf("%c[2K",27);
  62. }
  63.  
  64. tos() /* curser to top of screen */
  65. {
  66.   printf("%c[H",27);
  67. }
  68.  
  69. bos() /* curser to bottom of screen */
  70. {
  71.   printf("%c[23;0H",27);
  72. }
  73.  
  74. bold() /* bold text */
  75. {
  76.   printf("%c[1m",27);
  77. }
  78.  
  79. norm() /* normal text */
  80. {
  81.   printf("%c[0m",27);
  82. }
  83.  
  84. /* -------------------------------------------------------------------------
  85.  
  86.  
  87. reg_t mask_1  = {0x00000000, 0x0000000f};
  88. reg_t mask_2  = {0x00000000, 0x000000ff};
  89. reg_t mask_3  = {0x00000000, 0x00000fff};
  90. reg_t mask_4  = {0x00000000, 0x0000ffff};
  91. reg_t mask_5  = {0x00000000, 0x000fffff};
  92. reg_t mask_6  = {0x00000000, 0x00ffffff};
  93. reg_t mask_7  = {0x00000000, 0x0fffffff};
  94. reg_t mask_8  = {0x00000000, 0xffffffff};
  95. reg_t mask_9  = {0x0000000f, 0xffffffff};
  96. reg_t mask_10 = {0x000000ff, 0xffffffff};
  97. reg_t mask_11 = {0x00000fff, 0xffffffff};
  98. reg_t mask_12 = {0x0000ffff, 0xffffffff};
  99. reg_t mask_13 = {0x000fffff, 0xffffffff};
  100. reg_t mask_14 = {0x00ffffff, 0xffffffff};
  101. reg_t mask_15 = {0x0fffffff, 0xffffffff};
  102. reg_t mask_16 = {0xffffffff, 0xffffffff};
  103. reg_t mask_w  = {0xffffffff, 0xffffffff};
  104. reg_t mask_a  = {0x00000000, 0x000fffff};
  105. reg_t mask_x  = {0x00000000, 0x00000fff};
  106. reg_t mask_s  = {0xf0000000, 0x00000000};
  107. reg_t mask_m  = {0x0fffffff, 0xfffff000};
  108. reg_t mask_b  = {0x00000000, 0x000000ff};
  109. reg_t mask_xs = {0x00000000, 0x00000f00};
  110. reg_t mask_def= {0x00000000, 0x000fffff}; /* default - non .a defaults
  111. should be
  112.  OK */
  113. reg_t mask_p,mask_wp,mask_p1,mask_p2,mask_p3,mask_p4,mask_p5,mask_p6;
  114. reg_t mask_p7,mask_p8,mask_p9,mask_p10,mask_p11,mask_p12,mask_p13;
  115. reg_t mask_p14,mask_p15,mask_p16;
  116.  
  117. set_pmasks()
  118. {
  119.   short int i;
  120.   p[1] &= mask_1[1];
  121.   p[0] = 0;
  122.   if (p[1] < 8)
  123.   {
  124.     mask_p[0]  = 0x00000000;
  125.     mask_p[1] = 0x0000000f;
  126.     mask_wp[0] = 0x00000000;
  127.     mask_wp[1] = 0x0000000f;
  128.     for (i = 0; i < p[1]; ++i)
  129.     {
  130.       mask_p[1] == (mask_p[1] << (4*i));
  131.       mask_wp[1] |= mask_p[1];
  132.     }
  133.   }
  134.   else
  135.   {
  136.     mask_p[0]  = 0x0000000f;
  137.     mask_p[1]  = 0x00000000;
  138.     mask_wp[0] = 0x0000000f;
  139.     mask_wp[1] = 0x00000000;
  140.     for (i = 0; i < p[1]-8; ++i)
  141.     {
  142.       mask_p[0] == (mask_p[0] << (4*i));
  143.       mask_wp[0] |= mask_p[0];
  144.     }
  145.   }
  146.   mask_n(mask_p1,1);
  147.   mask_n(mask_p2,2);
  148.   mask_n(mask_p3,3);
  149.   mask_n(mask_p4,4);
  150.   mask_n(mask_p5,5);
  151.   mask_n(mask_p6,6);
  152.   mask_n(mask_p7,7);
  153.   mask_n(mask_p8,8);
  154.   mask_n(mask_p9,9);
  155.   mask_n(mask_p10,10);
  156.   mask_n(mask_p11,11);
  157.   mask_n(mask_p12,12);
  158.   mask_n(mask_p13,13);
  159.   mask_n(mask_p14,14);
  160.   mask_n(mask_p15,15);
  161.   mask_n(mask_p16,16);
  162. }
  163.  
  164. mask_n(reg,n)
  165. reg_t reg;
  166. int n;
  167. {
  168.   reg_t tmp1;
  169.   int i;
  170.  
  171.   reg[0] = 0;
  172.   reg[1] = 0;
  173.   if (p[1] < 8)
  174.   {
  175.     for (i = p[1]; (i < 8)&&(i<(n+p[1])); ++i) reg[1] |= (0xf << (4*i));
  176.     if (i < (n+p[1])) {for (i = 0; (i < 8)&&(i<(n+p[1]-8)); ++i) reg[0]
  177. |= (0xf<
  178. < (4*i));}
  179.   }
  180.   else
  181.   {
  182.     for (i = p[1]; (i < 8)&&(i<(n+p[1])); ++i) reg[0] |= (0xf << (4*i));
  183.   }
  184. }
  185.  
  186.  
  187. move(  mask, reg1, reg2)
  188. reg_t  mask, reg1, reg2;
  189. {
  190.   short int i;
  191.   if (®1[0]==&pc[0]) printf("Ignoring <move pc,register> instruction...\n");
  192.   else
  193.   {
  194.     if ((&mask[0]==&mask_def[0]) &&
  195.        (  (®1[0]==&r0[0])||(®2[0]==&r0[0])
  196.         ||(®1[0]==&r1[0])||(®2[0]==&r1[0])
  197.         ||(®1[0]==&r2[0])||(®2[0]==&r2[0])
  198.         ||(®1[0]==&r3[0])||(®2[0]==&r3[0])
  199.         ||(®1[0]==&r4[0])||(®2[0]==&r4[0]) )) {mask[0]=mask_w[0];
  200. mask[1]=
  201. mask_w[1];}
  202.  
  203.     for (i = 0; i < 2; ++i) reg2[i] = (reg2[i] & (~mask[i])) | (reg1[i] &
  204. mask[i
  205. ]);
  206.     if (®2[0]==&p[0]) set_pmasks();
  207.   }
  208. }
  209.  
  210. swap(  mask, reg1, reg2)
  211. reg_t  mask, reg1, reg2;
  212. {
  213.   short int i;
  214.   reg_t tmp1;
  215.   if ((&mask[0]==&mask_def[0]) &&
  216.      (  (®1[0]==&r0[0])||(®2[0]==&r0[0])
  217.       ||(®1[0]==&r1[0])||(®2[0]==&r1[0])
  218.       ||(®1[0]==&r2[0])||(®2[0]==&r2[0])
  219.       ||(®1[0]==&r3[0])||(®2[0]==&r3[0])
  220.       ||(®1[0]==&r4[0])||(®2[0]==&r4[0]) )) {mask[0]=mask_w[0];
  221. mask[1]=ma
  222. sk_w[1];}
  223.   for (i = 0; i < 2; ++i)
  224.   {
  225.     tmp1[i] = (reg2[i] & (~mask[i])) | (reg1[i] & mask[i]);
  226.     reg1[i] = (reg1[i] & (~mask[i])) | (reg2[i] & mask[i]);
  227.     reg2[i] = tmp1[i];
  228.   }
  229.   if (®2[0]==&p[0]) set_pmasks();
  230. }
  231.  
  232. push()
  233. {
  234.   stack[stkptr--] = c[0] & mask_a[0];
  235. }
  236.  
  237. pop()
  238. {
  239.   c[0] = ((c[0] & (~mask_a[0])) | (stack[stkptr++] & mask_a[0]));
  240. }
  241.  
  242. clr(   mask, reg1)
  243. reg_t  mask, reg1;
  244. {
  245.   short int i;
  246.   for (i = 0; i < 2; i++) reg1[i] &= (~mask[i]);
  247. }
  248.  
  249. and(   mask, reg1, reg2)
  250. reg_t  mask, reg1, reg2;
  251. {
  252.   short int i;
  253.   for (i = 0; i < 2; i++) reg2[i] = ((reg2[i] & (~mask[i])) | (reg2[i] &
  254. mask[i]
  255.  & reg1[i]));
  256. }
  257.  
  258. or(    mask, reg1, reg2)
  259. reg_t  mask, reg1, reg2;
  260. {
  261.   short int i;
  262.   for (i = 0; i < 2; i++) reg2[i] = ((reg2[i] & (~mask[i])) | ((reg2[i]
  263. |reg1[i]
  264. ) & mask[i]));
  265. }
  266.  
  267. inc(   mask, reg1)
  268. reg_t  mask, reg1;
  269. {
  270.   reg_t tmp1;
  271.   tmp1[0] = 0;
  272.   tmp1[1] = 1;
  273.   while (tmp1[1] && (!(tmp1[1] & mask[1]))) (tmp1[1] << 4);
  274.   if (!tmp1[1])
  275.   {
  276.     tmp1[0] = 1;
  277.     while (tmp1[0] && (!(tmp1[0] & mask[0]))) (tmp1[0] << 4);
  278.   }
  279.   add(mask,tmp1,reg1);
  280. }
  281.  
  282. dec(   mask, reg1)
  283. reg_t  mask, reg1;
  284. {
  285.   reg_t tmp1;
  286.   tmp1[0] = 0;
  287.   tmp1[1] = 1;
  288.   while (tmp1[1] && (!(tmp1[1] & mask[1]))) (tmp1[1] << 4);
  289.   if (!tmp1[1])
  290.   {
  291.     tmp1[0] = 1;
  292.     while (tmp1[0] && (!(tmp1[0] & mask[0]))) (tmp1[0] << 4);
  293.   }
  294.   sub(mask,tmp1,reg1);
  295. }
  296.  
  297.  
  298. add(   mask, reg1, reg2)
  299. reg_t  mask, reg1, reg2;
  300. {
  301.   unsigned long t;
  302.   reg2[1] += (reg1[1] & mask[1]);
  303.   if ( (((reg2[1] >> 4) + (reg1[1] & mask[1])) >> 4) & 0xf0000000 )
  304.   {
  305.     t = reg2[0];
  306.     reg2[0] += ( (reg1[0]+1) & mask[0] );
  307.     carry = (t+((reg1[0]+1) & mask[0]) != reg2[0]);
  308.   }
  309.   else
  310.   {
  311.     t = reg2[0];
  312.     reg2[0] += ( reg1[0] & mask[0] );
  313.     carry = (t+(reg1[0] & mask[0]) != reg2[0]);
  314.   }
  315.   if (®2[0]==&p[0]) set_pmasks();
  316. }
  317.  
  318.  
  319. sub(   mask, reg1, reg2)
  320. reg_t  mask, reg1, reg2;
  321. {
  322.   unsigned long t;
  323.   reg2[1] -= (reg1[1] & mask[1]);
  324.   if ((reg2[1] & mask[1]) < (reg1[1] & mask[1]))
  325.   {
  326.     t = reg2[0];
  327.     reg2[0] -= ( (reg1[0]+1) & mask[0] );
  328.     carry = (t-((reg1[0]+1) & mask[0]) != reg2[0]);
  329.   }
  330.   else
  331.   {
  332.     t = reg2[0];
  333.     reg2[0] -= ( reg1[0] & mask[0] );
  334.     carry = (t-(reg1[0] & mask[0]) != reg2[0]);
  335.   }
  336.   if (®2[0]==&p[0]) set_pmasks();
  337. }
  338.  
  339. not(   mask, reg1)
  340. reg_t  mask, reg1;
  341. {
  342.   carry = 0;
  343.   reg1[0] = (reg1[0] & (~mask[0])) | ((~reg1[0]) & mask[0]);
  344.   reg1[1] = (reg1[1] & (~mask[1])) | ((~reg1[1]) & mask[1]);
  345. }
  346.  
  347. neg(   mask, reg1)
  348. reg_t  mask, reg1;
  349. {
  350.   not(mask,reg1);
  351.   dec(mask,reg1);
  352. }
  353.  
  354. rrn(   mask, reg1)
  355. reg_t  mask, reg1;
  356. {
  357.   long i,store;
  358.   if (mask[1])
  359.   {
  360.     for (i=0xfL; (!(mask[1] & i)); i = i << 4);
  361.     store = reg1[1] & i;
  362.   }
  363.   else
  364.   {
  365.     for (i=0xfL; (!(mask[0] & i)); i = i < 4);
  366.     store = reg1[0] & i;
  367.   }
  368.   while (store > 0xfL) store = store >> 4;
  369.  
  370.   srn(mask,reg1);
  371.   if (store)
  372.   {
  373.     if (mask[0])
  374.     {
  375.       for (i=0xf0000000L; (!(mask[0] & i)); i = i >> 4);
  376.       while (!(store & i)) store = store << 4;
  377.       reg1[0] |= store;
  378.     }
  379.     else
  380.     {
  381.       for (i=0xf0000000L; (!(mask[1] & i)); i = i >> 4);
  382.       while (!(store & i)) store = store << 4;
  383.       reg1[1] |= store;
  384.     }
  385.   }
  386. }
  387.  
  388. rln(   mask, reg1)
  389. reg_t  mask, reg1;
  390. {
  391.   long i,store;
  392.   if (mask[0])
  393.   {
  394.     for (i=0xf0000000L; (!(mask[0] & i)); i = i >> 4);
  395.     store = reg1[0] & i;
  396.   }
  397.   else
  398.   {
  399.     for (i=0xf0000000L; (!(mask[1] & i)); i = i >> 4);
  400.     store = reg1[1] & i;
  401.   }
  402.   while (store > 0xfL) store = store >> 4;
  403.  
  404.   sln(mask,reg1);
  405.   if (store)
  406.   {
  407.     if (mask[1])
  408.     {
  409.       for (i=0xfL; (!(mask[1] & i)); i = i << 4);
  410.       while (!(store & i)) store = store << 4;
  411.       reg1[1] |= store;
  412.     }
  413.     else
  414.     {
  415.       for (i=0xfL; (!(mask[0] & i)); i = i << 4);
  416.       while (!(store & i)) store = store << 4;
  417.       reg1[0] |= store;
  418.     }
  419.   }
  420. }
  421.  
  422. srn(   mask, reg1)
  423. reg_t  mask, reg1;
  424. {
  425.   reg_t tmp1;
  426.   tmp1[1] = (((reg1[1] & mask[1]) >> 4L)|((reg1[0] & 0xfL) << 28L)) & mask[1];
  427.   tmp1[0] =   (reg1[0] & mask[0]) >> 4L;
  428.   reg1[0] = (reg1[0] & (~mask[0])) | (tmp1[0] & mask[0]);
  429.   reg1[1] = (reg1[1] & (~mask[1])) | (tmp1[1] & mask[1]);
  430. }
  431.  
  432. srb(   mask, reg1)
  433. reg_t  mask, reg1;
  434. {
  435.   reg_t tmp1;
  436.   tmp1[1] = (((reg1[1] & mask[1]) >> 1L)|((reg1[0] & 0x1L) << 31L)) & mask[1];
  437.   tmp1[0] =   (reg1[0] & mask[0]) >> 1L;
  438.   reg1[0] = (reg1[0] & (~mask[0])) | (tmp1[0] & mask[0]);
  439.   reg1[1] = (reg1[1] & (~mask[1])) | (tmp1[1] & mask[1]);
  440. }
  441.  
  442. sln(   mask, reg1)
  443. reg_t  mask, reg1;
  444. {
  445.   reg_t tmp1;
  446.   tmp1[1] =  ((reg1[1] & mask[1]) << 4L) & mask[1];
  447.   tmp1[0] = (((reg1[0] & mask[0]) << 4L)|((reg1[1] & 0xf0000000L) >>
  448. 28L)) & mas
  449. k[0];
  450.   reg1[0] = (reg1[0] & (~mask[0])) | (tmp1[0] & mask[0]);
  451.   reg1[1] = (reg1[1] & (~mask[1])) | (tmp1[1] & mask[1]);
  452. }
  453.  
  454.  
  455. constmp(mask, cons)
  456. reg_t mask;
  457. long cons;
  458. {
  459.   short int i;
  460.   i = 0;
  461.   while ((1 << i) && !((1 << i) & mask[1])) i += 4;
  462.   if (!(1 << (i-8))) while ((1 << (i-8)) && !((1 << (i-8)) & mask[0])) i += 4;
  463.   tmp[1] = (mask[1] & ( cons <<   i   ));
  464.   tmp[0] = (mask[0] & ( cons >> (8-i) ));
  465. }
  466.  
  467. show_regs()
  468. {
  469.   int i;
  470.   char strng1[17],strng2[17];
  471. printf("----------------------------------------------------------------------
  472. ---------\n");
  473.   printf("| a=%08X%08X b=%08X%08X c=%08X%08X d=%08X%08X
  474. |\n",a[0],a[1],b[0],b[1]
  475. ,c[0],c[1],d[0],d[1]);
  476.   printf("| d0 = %05X,     d1 = %05X,      status = %04X,      p = %1X,
  477.   carr
  478. y %s |\n",d0[1]&mask_a[1],d1[1]&mask_a[1],st[1]&mask_4[1],p[1],(carry) ?
  479. "set  "
  480.  :"clear");
  481. printf("----------------------------------------------------------------------
  482. ---------\n");
  483. }
  484.  
  485. input(fld, mask, reg1, reg2)
  486. reg_t mask, reg1, reg2;
  487. char fld[3];
  488. {
  489.   char instr[17],str1[9],str2[17];
  490.   int i;
  491.  
  492.   if((mask[0]==mask_a[0]) && (mask[1]==mask_a[1])) /* getting an address? */
  493.   {
  494.     switch (reg1[1]&mask_a[1]) /* is it known? */
  495.     {
  496.       case d0_init:         {reg2[1]=(reg2[1] & (~mask[1]))      | (RPL &
  497. mask[1
  498. ]); return; break; }
  499.       case d1_init:         {reg2[1]=(reg2[1] & (~mask[1]))      | (ST0 &
  500. mask[1
  501. ]); return; break; }
  502.       case (5 +d1_init):    {reg2[1]=(reg2[1] & (~mask[1])) | (ST1
  503. &mask[1]); re
  504. turn; break; }
  505.       case (10+d1_init):    {reg2[1]=(reg2[1] & (~mask[1])) | (ST2 &
  506. mask[1]); r
  507. eturn; break; }
  508.       case (15+d1_init):    {reg2[1]=(reg2[1] & (~mask[1])) | (ST3 &
  509. mask[1]); r
  510. eturn; break; }
  511.       case (20+d1_init):    {reg2[1]=(reg2[1] & (~mask[1])) | (ST4 &
  512. mask[1]); r
  513. eturn; break; }
  514.       case ST0:             {intype(mask,reg2,1); return; break;}
  515.       case ST1:             {intype(mask,reg2,1); return; break;}
  516.       case ST2:             {intype(mask,reg2,2); return; break;}
  517.       case ST3:             {intype(mask,reg2,3); return; break;}
  518.       case ST4:             {intype(mask,reg2,4); return; break;}
  519.       case (ST0+5):         {printf("Input from Stack[0]+5: "); break;}
  520.       case (ST0+10):        {printf("Input from Stack[0]+10: "); break;}
  521.       case (ST1+5):         {printf("Input from Stack[1]+5: "); break;}
  522.       case (ST1+10):        {printf("Input from Stack[1]+10: "); break;}
  523.       case (ST2+5):         {printf("Input from Stack[2]+5: "); break;}
  524.       case (ST2+10):        {printf("Input from Stack[2]+10: "); break;}
  525.       case (ST3+5):         {printf("Input from Stack[3]+5: "); break;}
  526.       case (ST3+10):        {printf("Input from Stack[3]+10: "); break;}
  527.       case (ST4+5):         {printf("Input from Stack[4]+5: "); break;}
  528.       case (ST4+10):        {printf("Input from Stack[4]+10: "); break;}
  529.     }
  530.   }
  531.  
  532.   for (i = 0; i < 16; ++i) instr[i] = 48;
  533.   instr[17] = 0;
  534.   for (i = 0; i < 8 && !( (1<<(4*i)) & mask[1]); ++i);
  535.   if (i == 8) for (i = 8;i < 16 & !( (1<<((4*i)-32)) & mask[0]); ++i);
  536.  
  537.   printf("Input [%3s] field (in hex) stored at %05X: ",fld,(reg1[1] &
  538. mask_a[1])
  539.  );
  540.   scanf("%s",str2);
  541.   printf("\n");
  542.   strncpy(&instr[16-i-strlen(str2)],str2,strlen(str2));
  543.   strncpy(str1,instr,8);
  544.   str1[8]=0;
  545.   reg2[0] = (reg2[0] & (~mask[0])) | (strtoul(str1,NULL,16) & mask[0]);
  546.   reg2[1] = (reg2[1] & (~mask[1])) | (strtoul(&instr[8],NULL,16) & mask[1]);
  547. }
  548.  
  549. output(fld, mask, reg1, reg2)
  550. reg_t mask, reg1, reg2;
  551. char fld[3];
  552. {
  553.   if (mask[0] && mask[1]) printf("[%s] field of @[%05X] <=
  554. %x%0x\n",fld,reg2[1]&
  555. mask_a[1],reg1[0]&mask[0],reg1[1]&mask[1]);
  556.   else if (mask[0] && !mask[1]) printf("[%s] field of @[%05X] <=
  557. %x\n",fld,reg2[
  558. 1]&mask_a[1],reg1[0]&mask[0]);
  559.   else printf("[%s] field of @[%05X] is now
  560. %x\n",fld,reg2[1]&mask_a[1],reg1[1]&
  561. mask[1]);
  562. }
  563.  
  564.  
  565. intype(mask,reg2,lvl)
  566. reg_t mask, reg2;
  567. int lvl;
  568. {
  569.   int i;
  570.  
  571.   printf("Input type of object in level %d of display:\n\n      (0)
  572. String\n
  573.         (1)     Real\n  (2)     Inline machine code\n   (3)     Algebraic
  574. obj\n
  575. (4)     Programme\n     (5)     Global Name\n   (6)     Local Name\n
  576. (7)
  577. Binary Integer\n",lvl);
  578.  
  579.   scanf("%d",&i);
  580.   switch (i)
  581.   {
  582.     case 0: {reg2[1]=(reg2[1] & (~mask[1])) | (STRTYP & mask[1]); break;}
  583.     case 1: {reg2[1]=(reg2[1] & (~mask[1])) | (REATYP & mask[1]); break;}
  584.     case 2: {reg2[1]=(reg2[1] & (~mask[1])) | (IMCTYP & mask[1]); break;}
  585.     case 3: {reg2[1]=(reg2[1] & (~mask[1])) | (ALGTYP & mask[1]); break;}
  586.     case 4: {reg2[1]=(reg2[1] & (~mask[1])) | (PRGTYP & mask[1]); break;}
  587.     case 5: {reg2[1]=(reg2[1] & (~mask[1])) | (NAMTYP & mask[1]); break;}
  588.     case 6: {reg2[1]=(reg2[1] & (~mask[1])) | (LOCTYP & mask[1]); break;}
  589.     case 7: {reg2[1]=(reg2[1] & (~mask[1])) | (BINTYP & mask[1]); break;}
  590.     default: printf("error, unknown type\n");
  591.   }
  592.   printf("\n");
  593. }
  594.  
  595. getstep(char *cmd)
  596. {
  597.   char cnt[5];
  598.   static int step_count=1;
  599.  
  600.   printf ("%s\n",cmd);
  601.   if (!(--step_count))
  602.   {
  603.     tos();
  604.     bold();
  605.     show_regs();
  606.     bos();
  607.     printf("\n%c%c%c clr,set,qui,n-steps: ",9,9,9);
  608.     norm();
  609.     scanf("%s",cnt);
  610.     while ((!strcmp(cnt,"clr"))||(!strcmp(cnt,"set")))
  611.     {
  612.       if(!strcmp(cnt,"clr"))
  613.       {
  614.         cls();
  615.         bos();
  616.         printf ("%s",cmd);
  617.         printf ("\n");  /* for some reason, I need to do it this way on
  618. my term
  619. */
  620.       }
  621.       else
  622.       {
  623.         bold();
  624.         printf("Enter name of register (a,b,c,d,d0,d1,st,p,car): ");
  625.         norm();
  626.         scanf("%s",cnt);
  627.         ebl();
  628.         if (!strcmp(cnt,"car"))
  629.         {
  630.           bold();
  631.           printf("Set/Clear? (s/c)");
  632.           norm();
  633.           scanf("%c",cnt);
  634.           if (cnt[0]==115) carry=1; else carry=0;
  635.         }
  636.         else if (!strcmp(cnt,"p"))
  637.         {
  638.           bold();
  639.           printf("Enter HEX value (1 nybble): ");
  640.           norm();
  641.           scanf("%1x",&p[1]);
  642.           set_pmasks();
  643.         }
  644.         else if (!strcmp(cnt,"st"))
  645.         {
  646.           bold();
  647.           printf("Enter HEX value (4 nybbles): ");
  648.           norm();
  649.           scanf("%4x",&st[1]);
  650.         }
  651.         else if (!strcmp(cnt,"d0"))
  652.         {
  653.           bold();
  654.           printf("Enter new value (in HEX) (5 nybbles): ");
  655.           norm();
  656.           scanf("%5x",&d0[1]);
  657.         }
  658.         else if (!strcmp(cnt,"d1"))
  659.         {
  660.           bold();
  661.           printf("Enter new value (in HEX) (5 nybbles): ");
  662.           norm();
  663.           scanf("%5x",&d1[1]);
  664.         }
  665.         else if (!strcmp(cnt,"a"))
  666.         {
  667.           bold();
  668.           printf("Enter new value (in HEX) (16 nyb incl leading 0s): ");
  669.           norm();
  670.           scanf("%16x",&a[0],&a[1]);
  671.         }
  672.         else if (!strcmp(cnt,"b"))
  673.         {
  674.           bold();
  675.           printf("Enter new value (in HEX) (16 nyb incl leading 0s): ");
  676.           norm();
  677.           scanf("%16x",&b[0],&b[1]);
  678.         }
  679.         else if (!strcmp(cnt,"c"))
  680.         {
  681.           bold();
  682.           printf("Enter new value (in HEX) (16 nyb incl leading 0s): ");
  683.           norm();
  684.           scanf("%16x",&c[0],&c[1]);
  685.         }
  686.         else if (!strcmp(cnt,"d"))
  687.         {
  688.           bold();
  689.           printf("Enter new value (in HEX) (16 nybs incl leading 0s): ");
  690.           norm();
  691.           scanf("%16x",&d[0],&d[1]);
  692.         }
  693.         else printf("Illegal register name - ignored");
  694.         printf("\n");
  695.       }
  696.       tos();
  697.       bold();
  698.       show_regs();
  699.       bos();
  700.       printf("\n%c%c%c clr,set,qui,n-steps: ",9,9,9);
  701.       norm();
  702.       scanf("%s",cnt);
  703.     }
  704.     if (!strcmp(cnt,"qui"))
  705.     {
  706.       cls();
  707.       tos();
  708.       exit(0);
  709.     }
  710.     ebl();
  711.     step_count=strtol(cnt,NULL,10);
  712.     if (!step_count) step_count = 1;
  713.   }
  714. }
  715.  
  716.  
  717.